#####################################################################################
#
#   The controller class, the class that runs them all. Loads and sets up ...
#   ... everything then runs the main event loop (RubyGame version).
#
#####################################################################################







#####################################################################################
#   The SHOOTINGGAMECONTROLLER class :
#####################################################################################
class ShootingGameController

  attr_accessor :screen, :width, :height,
                :player



  ###################################################################################
  # CREATING a new instance of the class :
  ###################################################################################
  def initialize(w, h, file)


    ### The RubyGame part : #########################################################

    ### First, the SCREEN SETUP : ###################################################
    @width  = w
    @height = h

    @screen = Screen.new([@width, @height], 0, HWSURFACE)
    @screen.title = "RubyGameBulletML"
    @screen.show_cursor = false
    @fullScreenFlag = false                                 # Starting in window ...
    # ... mode.


    ### Second, the JOYSTICK SETUP : ################################################
    if Joystick.num_joysticks > 0 then
      @joystick = Joystick.new(0)
      print "Could not connect to joystick 0.\n" if @joystick == SDLError
    else
      print "No joystick found.\nUse the keyboard.\n"
    end


    ### Third, the EVENT MANAGEMENT : ###############################################
    @events = EventQueue.new

    @clock = Clock.new
    @clock.target_framerate = 60


    ### Last, Loading the images : ##################################################
    playerImage, playerRect = loadImage("../Images/vaisseau.bmp", -1)
    sourceImage, sourceRect = loadImage("../Images/source.bmp", -1)
    bulletImage, bulletRect = loadImage("../Images/boulette.bmp", -1)



    ### The RubyBulletML part : #####################################################

    ### The fixed math initialization : #############################################
    Trigo.initialize

    ### Creating a PLAYER instance : ################################################
    @player             = Player.new(self, @width/2, 4*@height/5, 0.0)

    @player.setImage(playerImage, playerRect)


    ### The BULLETML part : #########################################################

    # READING and PARSING the B_ML XML files describing this source's patern :
    @bulletMLSources = [] << BulletML.new(file)

    # ASSIGNING the B_ML objects to b_ml INTERPRETER instances :
    @liveBulletSources = [] << CustomBulletSource.new(self,
                                                      @width/2.0, @height*0.2,
                                                      @bulletMLSources[0])

    @liveBulletSources.last.setImage(sourceImage, sourceRect)
    @liveBulletSources.last.setBulletImage(bulletImage, bulletRect)
    #@liveBulletSources.last.scaling = 2.0


    ### FINAL SETUP : ###############################################################
    @screen.fill([0, 0, 0])
    @screen.update

  end



  ###################################################################################
  # Running the EVENT LOOP :
  ###################################################################################
  def run

    # Starting a loop that can only be exited when either the ESCAPE key or a ...   #
    # ... specific joystick button has been pressed :                               #
    #################################################################################
    loop do

      @clock.tick                             # Waiting in order to garanty a ...
      # ... fixed frame rate.

      # Parsing the events :                                                        #
      ###############################################################################
      @events.each do |event|

        @player.eventResponse(event)          # Forwarding the event to the ...
        # ... player instance so it   ...
        # ... can update itself       ...
        # ... accordingly.

        # What is this event made of ?                                              #
        # ( the button assignments are for a PS3 Fighting Stick 3 )                 #
        #############################################################################
        case event
        when QuitEvent #--------------------------------------- QuitEvent : ---------
          return

        when JoyDownEvent #------------------------------------ JoyDownEvent : ------
          case event.button

          when 8                        # Switching from windowed to full screen mode
            if @fullScreenFlag
              @fullScreenFlag = false
              @screen = Screen.new([@width, @height], 0, HWSURFACE)
            else
              @fullScreenFlag = true
              @screen = Screen.new([@width, @height], 0, HWSURFACE | FULLSCREEN)
            end

          when 12                       # Quitting
            return
          end

        when KeyDownEvent #------------------------------------ KeyDownEvent : ------
          case event.key

          when K_F                      # Switching from windowed to full screen mode
            if @fullScreenFlag
              @fullScreenFlag = false
              @screen = Screen.new([@width, @height], 0, HWSURFACE)
            else
              @fullScreenFlag = true
              @screen = Screen.new([@width, @height], 0, HWSURFACE | FULLSCREEN)
            end

          when K_R                      # Reseting
            @liveBulletSources.each do |lbs| lbs.reset end

          when K_ESCAPE                 # Quitting
            return
          end

        end
      end


      # Running all the game's elements behaviors :
      @player.run
      @liveBulletSources.each do |lbs| lbs.run end


      # Drawing all the game's elements :
      @screen.fill([10, 10, 10])
      @player.draw
      @liveBulletSources.each do |lbs| lbs.draw end
      @screen.update

    end
  end

end ### End of the SHOOTINGGAMECONTROLLER class #####################################







#####################################################################################
# LOADING an image and returning the bitmap and its enclosing RECT :                #
#####################################################################################
def loadImage(name, colorkey=nil)
  image = Rubygame::Surface.load_image(name)
  if colorkey != nil
    if colorkey == -1
      colorkey = image.get_at([0,0])
    end
    image.set_colorkey(colorkey)
  end
  return image, Rubygame::Rect.new(0,0,*image.size)
end
